/**
 * 本地存储工具函数
 * 用于管理聊天记录的持久化存储
 * 支持多会话管理
 */

const SESSIONS_KEY = 'agent_sessions' // 存储所有会话
const CURRENT_SESSION_KEY = 'agent_current_session_id' // 当前会话ID

// 配置：每个会话最多保存的消息数量
const MAX_MESSAGES_PER_SESSION = 2000 // 最多保存2000条消息

/**
 * 生成会话ID
 */
export const generateSessionId = () => {
  return `session_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`
}

/**
 * 获取所有会话列表
 */
export const getAllSessions = () => {
  try {
    const data = localStorage.getItem(SESSIONS_KEY)
    if (!data) {
      return []
    }
    const sessions = JSON.parse(data)
    return Array.isArray(sessions) ? sessions : []
  } catch (error) {
    console.error('获取会话列表失败:', error)
    return []
  }
}

/**
 * 保存会话列表
 */
const saveAllSessions = (sessions) => {
  try {
    localStorage.setItem(SESSIONS_KEY, JSON.stringify(sessions))
    return true
  } catch (error) {
    console.error('保存会话列表失败:', error)
    return false
  }
}

/**
 * 获取当前会话ID
 */
export const getCurrentSessionId = () => {
  let sessionId = localStorage.getItem(CURRENT_SESSION_KEY)
  if (!sessionId) {
    // 检查是否有会话列表
    const sessions = getAllSessions()
    if (sessions.length > 0) {
      // 如果有会话，使用第一个
      sessionId = sessions[0].id
      setCurrentSessionId(sessionId)
    } else {
      // 如果没有会话，创建一个新会话
      sessionId = createNewSession()
    }
  }
  return sessionId
}

/**
 * 设置当前会话ID
 */
export const setCurrentSessionId = (sessionId) => {
  localStorage.setItem(CURRENT_SESSION_KEY, sessionId)
}

/**
 * 创建新会话
 */
export const createNewSession = (title = null) => {
  const sessionId = generateSessionId()
  const sessions = getAllSessions()
  
  // 生成会话标题（使用第一条用户消息的前20个字符）
  const sessionTitle = title || `新会话 ${new Date().toLocaleString('zh-CN', { month: 'short', day: 'numeric', hour: '2-digit', minute: '2-digit' })}`
  
  const newSession = {
    id: sessionId,
    title: sessionTitle,
    createdAt: Date.now(),
    lastUpdated: Date.now(),
    messageCount: 0
  }
  
  sessions.unshift(newSession) // 添加到列表开头
  saveAllSessions(sessions)
  setCurrentSessionId(sessionId)
  
  // 初始化会话的聊天记录
  saveChatHistory(sessionId, [])
  
  return sessionId
}

/**
 * 获取会话信息
 */
export const getSession = (sessionId) => {
  const sessions = getAllSessions()
  return sessions.find(s => s.id === sessionId)
}

/**
 * 更新会话信息
 */
export const updateSession = (sessionId, updates) => {
  const sessions = getAllSessions()
  const index = sessions.findIndex(s => s.id === sessionId)
  if (index !== -1) {
    sessions[index] = { ...sessions[index], ...updates, lastUpdated: Date.now() }
    saveAllSessions(sessions)
    return true
  }
  return false
}

/**
 * 删除会话
 */
export const deleteSession = (sessionId) => {
  const sessions = getAllSessions()
  const filtered = sessions.filter(s => s.id !== sessionId)
  saveAllSessions(filtered)
  
  // 删除会话的聊天记录
  localStorage.removeItem(`session_${sessionId}`)
  
  // 如果删除的是当前会话，切换到第一个会话或创建新会话
  if (sessionId === getCurrentSessionId()) {
    if (filtered.length > 0) {
      setCurrentSessionId(filtered[0].id)
    } else {
      createNewSession()
    }
  }
  
  return true
}

/**
 * 保存聊天记录到本地存储
 */
export const saveChatHistory = (sessionId, messages) => {
  try {
    const targetSessionId = sessionId || getCurrentSessionId()
    
    // 限制消息数量：只保存最近N条消息
    let messagesToSave = messages
    if (messages.length > MAX_MESSAGES_PER_SESSION) {
      // 只保留最近的N条消息
      messagesToSave = messages.slice(-MAX_MESSAGES_PER_SESSION)
      console.warn(`消息数量超过限制(${MAX_MESSAGES_PER_SESSION}条)，已自动清理旧消息`)
    }
    
    const history = {
      sessionId: targetSessionId,
      messages: messagesToSave.map(msg => ({
        id: msg.id,
        role: msg.role,
        content: msg.content,
        timestamp: msg.timestamp,
        status: msg.status,
        items: msg.items || null, // 保存 items 数组（按时间顺序的工具调用和文本块）
        toolCalls: msg.toolCalls || null, // 兼容旧格式：保存工具调用信息
        checkpointId: msg.checkpointId || null, // 保存 checkpoint ID 用于时间旅行
        // 不保存 audio 数据，因为音频数据太大
        // audio: msg.audio
      })),
      lastUpdated: Date.now()
    }
    
    // 使用会话ID作为key的一部分
    const storageKey = `session_${targetSessionId}`
    localStorage.setItem(storageKey, JSON.stringify(history))
    
    // 更新会话信息
    const session = getSession(targetSessionId)
    if (session) {
      const firstUserMessage = messagesToSave.find(msg => msg.role === 'user')
      const updates = {
        messageCount: messagesToSave.length,
        lastUpdated: Date.now()
      }
      
      // 如果会话标题还是默认标题，且有了第一条用户消息，更新标题
      if (firstUserMessage && (session.title.startsWith('新会话') || !session.title)) {
        const title = firstUserMessage.content.trim().substring(0, 20) || '新会话'
        updates.title = title
      }
      
      updateSession(targetSessionId, updates)
    } else {
      // 如果会话不存在，创建一个新会话
      const firstUserMessage = messagesToSave.find(msg => msg.role === 'user')
      const title = firstUserMessage ? firstUserMessage.content.trim().substring(0, 20) : '新会话'
      // 注意：这里不应该调用createNewSession，因为会创建新的sessionId
      // 而是应该直接创建会话记录
      const sessions = getAllSessions()
      const newSession = {
        id: targetSessionId,
        title: title,
        createdAt: Date.now(),
        lastUpdated: Date.now(),
        messageCount: messagesToSave.length
      }
      sessions.unshift(newSession)
      saveAllSessions(sessions)
    }
    
    return true
  } catch (error) {
    console.error('保存聊天记录失败:', error)
    return false
  }
}

/**
 * 从本地存储加载聊天记录
 */
export const loadChatHistory = (sessionId = null) => {
  try {
    if (!sessionId) {
      sessionId = getCurrentSessionId()
    }
    
    const storageKey = `session_${sessionId}`
    const data = localStorage.getItem(storageKey)
    if (!data) {
      return []
    }
    
    const history = JSON.parse(data)
    if (!history.messages || !Array.isArray(history.messages)) {
      return []
    }
    
    return history.messages
  } catch (error) {
    console.error('加载聊天记录失败:', error)
    return []
  }
}

/**
 * 清空聊天记录
 */
export const clearChatHistory = (sessionId = null) => {
  try {
    if (!sessionId) {
      sessionId = getCurrentSessionId()
    }
    
    const storageKey = `session_${sessionId}`
    localStorage.removeItem(storageKey)
    
    // 更新会话信息
    updateSession(sessionId, {
      messageCount: 0,
      lastUpdated: Date.now()
    })
    
    return true
  } catch (error) {
    console.error('清空聊天记录失败:', error)
    return false
  }
}

/**
 * 获取会话ID（兼容旧版本）
 */
export const getSessionId = () => {
  return getCurrentSessionId()
}

/**
 * 设置会话ID（兼容旧版本）
 */
export const setSessionId = (sessionId) => {
  setCurrentSessionId(sessionId)
}

